package day16.xianchengdemo.chuangjian;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//实现Callable接口,可以得到子线程的返回值
public class demo3
{
    public static void main(String[] args) {
         Callable<String> c1 = new MyCallable(100);//普通的任务对象，要封装成线程任务对象
        FutureTask<String> f1=new FutureTask<>(c1);
        /**
        *     未来任务对象作用
         *     1本质是一个线程任务对象 Runnable<String> re=new FutureTask(callable);
         *     2拿到子线程的返回值
         *
        *
        *
        * */
        Thread td=new Thread(f1);
        td.start();


        Callable<String> c2 = new MyCallable(50);//普通的任务对象，要封装成线程任务对象
        FutureTask<String> f2=new FutureTask<>(c2);
        Thread td2=new Thread(f2);
        td2.start();


        try {
            //当主线程跑到这，调get方法时候，如果发现第一个线程还没执行完毕，会让出cpu让第一个线程先执行完毕拿到返回值，主线程才会继续
            System.out.println(f1.get());//拿子线程的返回值

        } catch (Exception e) {
            throw new RuntimeException(e);
        }


        try {
            //当主线程跑到这，调get方法时候，如果发现第二个线程还没执行完毕，会让出cpu让第二个线程先执行完毕拿到返回值，主线程才会继续
            System.out.println(f2.get());//放一起可能会导致第一个get报了异常，第二个连get都没来得及调用就到了catch
        } catch (Exception e) {
            throw new RuntimeException(e);
        }





        for(int i = 0; i < 5;i++)
         {System.out.println("主线程");}
    }
}
class MyCallable implements Callable<String>//普通任务类
{   private int n;
    MyCallable(){}
    public MyCallable(int n){this.n=n;}
    public String call()throws Exception
    {     int sum=0;
          for(int i = 1;i <= this.n;i++)
          {
              sum+=i;
             // System.out.println("子线程");
          }
          return "子线程1："+"n="+n+"的计算结果是："+sum;
    }

}

